macro_rules! magic_number {
    ($name:ident, $value:expr) => {
        const $name: u32 = $value;
    };
}
magic_number!(KEYC_SENT, 0x40000000);

extern "C" {
    pub type sockaddr_x25;
    pub type sockaddr_ns;
    pub type sockaddr_iso;
    pub type sockaddr_ipx;
    pub type sockaddr_inarp;
    pub type sockaddr_eon;
    pub type sockaddr_dl;
    pub type sockaddr_ax25;
    pub type sockaddr_at;
    pub type _IO_wide_data;
    pub type _IO_codecvt;
    pub type _IO_marker;
    pub type event_base;
    pub type evbuffer;
    pub type bufferevent_ops;
    pub type args;
    pub type tmuxpeer;
    pub type hyperlinks;
    pub type screen_write_cline;
    pub type screen_sel;
    pub type screen_titles;
    pub type environ;
    pub type options;
    pub type format_tree;
    pub type input_ctx;
    pub type cmds;
    pub type tty_key;
    pub type tty_code;
    pub type format_job_tree;
    pub type control_state;
    pub type cmdq_list;
    pub type options_entry;
    pub type tmuxproc;
    fn socket(__domain: i32, __type: i32, __protocol: i32) -> i32;
    fn bind(__fd: i32, __addr: __CONST_SOCKADDR_ARG, __len: socklen_t) -> i32;
    fn accept(__fd: i32, __addr: __SOCKADDR_ARG, __addr_len: *mut socklen_t) -> i32;
    fn listen(__fd: i32, __n: i32) -> i32;
    fn stat(__file: *const i8, __buf: *mut stat) -> i32;
    fn chmod(__file: *const i8, __mode: __mode_t) -> i32;
    fn umask(__mask: __mode_t) -> __mode_t;
    fn memset(_: *mut (), _: i32, _: u64) -> *mut ();
    fn strerror(_: i32) -> *mut i8;
    fn strsignal(__sig: i32) -> *mut i8;
    fn close(__fd: i32) -> i32;
    fn unlink(__name: *const i8) -> i32;
    fn sigprocmask(__how: i32, __set: *const sigset_t, __oset: *mut sigset_t) -> i32;
    fn sigfillset(__set: *mut sigset_t) -> i32;
    fn killpg(__pgrp: __pid_t, __sig: i32) -> i32;
    fn kill(__pid: __pid_t, __sig: i32) -> i32;
    fn waitpid(__pid: __pid_t, __stat_loc: *mut i32, __options: i32) -> __pid_t;
    fn __errno_location() -> *mut i32;
    static mut stderr: *mut FILE;
    fn fprintf(_: *mut FILE, _: *const i8, _: ...) -> i32;
    fn free(_: *mut ());
    fn exit(_: i32) -> !;
    fn time(__timer: *mut time_t) -> time_t;
    fn event_reinit(base: *mut event_base) -> i32;
    fn event_add(ev: *mut event, timeout: *const timeval) -> i32;
    fn event_del(_: *mut event) -> i32;
    fn event_initialized(ev: *const event) -> i32;
    fn event_set(
        _: *mut event,
        _: i32,
        _: i16,
        _: Option<unsafe extern "C" fn(i32, i16, *mut ()) -> ()>,
        _: *mut (),
    );
    fn malloc_trim(__pad: size_t) -> i32;
    fn strlcpy(_: *mut i8, _: *const i8, _: size_t) -> size_t;
    fn xcalloc(_: size_t, _: size_t) -> *mut ();
    fn xstrdup(_: *const i8) -> *mut i8;
    fn xasprintf(_: *mut *mut i8, _: *const i8, _: ...) -> i32;
    fn xvasprintf(_: *mut *mut i8, _: *const i8, _: ::core::ffi::VaList) -> i32;
    static mut global_options: *mut options;
    static mut start_time: timeval;
    static mut socket_path: *const i8;
    fn setblocking(_: i32, _: i32);
    fn get_timer() -> uint64_t;
    fn proc_start(_: *const i8) -> *mut tmuxproc;
    fn proc_loop(_: *mut tmuxproc, _: Option<unsafe extern "C" fn() -> i32>);
    fn proc_set_signals(_: *mut tmuxproc, _: Option<unsafe extern "C" fn(i32) -> ()>);
    fn proc_clear_signals(_: *mut tmuxproc, _: i32);
    fn proc_toggle_log(_: *mut tmuxproc);
    fn proc_fork_and_daemon(_: *mut i32) -> pid_t;
    fn format_tidy_jobs();
    fn options_get_number(_: *mut options, _: *const i8) -> i64;
    fn options_set_number(_: *mut options, _: *const i8, _: i64) -> *mut options_entry;
    fn job_check_died(_: pid_t, _: i32);
    fn job_kill_all();
    fn job_still_running() -> i32;
    fn tty_create_log();
    fn gettimeofday(__tv: *mut timeval, __tz: *mut ()) -> i32;
    fn cmd_find_clear_state(_: *mut cmd_find_state, _: i32);
    fn cmd_find_valid_state(_: *mut cmd_find_state) -> i32;
    fn cmdq_next(_: *mut client) -> u_int;
    fn cmd_wait_for_flush();
    fn key_bindings_init();
    fn status_prompt_save_history();
    fn server_client_loop();
    fn server_client_create(_: i32) -> *mut client;
    fn input_key_build();
    fn server_destroy_pane(_: *mut window_pane, _: i32);
    fn server_client_lost(_: *mut client);
    fn windows_RB_MINMAX(_: *mut windows, _: i32) -> *mut window;
    fn windows_RB_NEXT(_: *mut window) -> *mut window;
    fn window_pane_destroy_ready(_: *mut window_pane) -> i32;
    static mut windows: windows;
    static mut all_window_panes: window_pane_tree;
    fn session_destroy(_: *mut session, _: i32, _: *const i8);
    fn sessions_RB_MINMAX(_: *mut sessions, _: i32) -> *mut session;
    fn sessions_RB_NEXT(_: *mut session) -> *mut session;
    static mut sessions: sessions;
    fn log_get_level() -> i32;
    fn fatalx(_: *const i8, _: ...) -> !;
    fn log_debug(_: *const i8, _: ...);
    fn server_acl_init();
    fn fatal(_: *const i8, _: ...) -> !;
    fn server_acl_join(_: *mut client) -> i32;
}
pub type __builtin_va_list = [__va_list_tag; 1];
#[derive(Copy, Clone)]
#[repr(C)]
pub struct __va_list_tag {
    pub gp_offset: u32,
    pub fp_offset: u32,
    pub overflow_arg_area: *mut (),
    pub reg_save_area: *mut (),
}
pub type __u_char = u8;
pub type __u_short = u16;
pub type __u_int = u32;
pub type __uint8_t = u8;
pub type __uint16_t = u16;
pub type __uint32_t = u32;
pub type __uint64_t = u64;
pub type __dev_t = u64;
pub type __uid_t = u32;
pub type __gid_t = u32;
pub type __ino_t = u64;
pub type __mode_t = u32;
pub type __nlink_t = u64;
pub type __off_t = i64;
pub type __off64_t = i64;
pub type __pid_t = i32;
pub type __time_t = i64;
pub type __suseconds_t = i64;
pub type __blksize_t = i64;
pub type __blkcnt_t = i64;
pub type __syscall_slong_t = i64;
pub type __socklen_t = u32;
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type mode_t = __mode_t;
pub type pid_t = __pid_t;
pub type time_t = __time_t;
pub type size_t = u64;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct __sigset_t {
    pub __val: [u64; 16],
}
pub type sigset_t = __sigset_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct timespec {
    pub tv_sec: __time_t,
    pub tv_nsec: __syscall_slong_t,
}
pub type socklen_t = __socklen_t;
pub type __socket_type = u32;
pub const SOCK_NONBLOCK: __socket_type = 2048;
pub const SOCK_CLOEXEC: __socket_type = 524288;
pub const SOCK_PACKET: __socket_type = 10;
pub const SOCK_DCCP: __socket_type = 6;
pub const SOCK_SEQPACKET: __socket_type = 5;
pub const SOCK_RDM: __socket_type = 4;
pub const SOCK_RAW: __socket_type = 3;
pub const SOCK_DGRAM: __socket_type = 2;
pub const SOCK_STREAM: __socket_type = 1;
pub type sa_family_t = u16;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sockaddr {
    pub sa_family: sa_family_t,
    pub sa_data: [i8; 14],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sockaddr_storage {
    pub ss_family: sa_family_t,
    pub __ss_padding: [i8; 118],
    pub __ss_align: u64,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union __SOCKADDR_ARG {
    pub __sockaddr__: *mut sockaddr,
    pub __sockaddr_at__: *mut sockaddr_at,
    pub __sockaddr_ax25__: *mut sockaddr_ax25,
    pub __sockaddr_dl__: *mut sockaddr_dl,
    pub __sockaddr_eon__: *mut sockaddr_eon,
    pub __sockaddr_in__: *mut sockaddr_in,
    pub __sockaddr_in6__: *mut sockaddr_in6,
    pub __sockaddr_inarp__: *mut sockaddr_inarp,
    pub __sockaddr_ipx__: *mut sockaddr_ipx,
    pub __sockaddr_iso__: *mut sockaddr_iso,
    pub __sockaddr_ns__: *mut sockaddr_ns,
    pub __sockaddr_un__: *mut sockaddr_un,
    pub __sockaddr_x25__: *mut sockaddr_x25,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sockaddr_un {
    pub sun_family: sa_family_t,
    pub sun_path: [i8; 108],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sockaddr_in6 {
    pub sin6_family: sa_family_t,
    pub sin6_port: in_port_t,
    pub sin6_flowinfo: uint32_t,
    pub sin6_addr: in6_addr,
    pub sin6_scope_id: uint32_t,
}
pub type uint32_t = __uint32_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct in6_addr {
    pub __in6_u: C2RustUnnamed,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed {
    pub __u6_addr8: [uint8_t; 16],
    pub __u6_addr16: [uint16_t; 8],
    pub __u6_addr32: [uint32_t; 4],
}
pub type uint16_t = __uint16_t;
pub type uint8_t = __uint8_t;
pub type in_port_t = uint16_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sockaddr_in {
    pub sin_family: sa_family_t,
    pub sin_port: in_port_t,
    pub sin_addr: in_addr,
    pub sin_zero: [u8; 8],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct in_addr {
    pub s_addr: in_addr_t,
}
pub type in_addr_t = uint32_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub union __CONST_SOCKADDR_ARG {
    pub __sockaddr__: *const sockaddr,
    pub __sockaddr_at__: *const sockaddr_at,
    pub __sockaddr_ax25__: *const sockaddr_ax25,
    pub __sockaddr_dl__: *const sockaddr_dl,
    pub __sockaddr_eon__: *const sockaddr_eon,
    pub __sockaddr_in__: *const sockaddr_in,
    pub __sockaddr_in6__: *const sockaddr_in6,
    pub __sockaddr_inarp__: *const sockaddr_inarp,
    pub __sockaddr_ipx__: *const sockaddr_ipx,
    pub __sockaddr_iso__: *const sockaddr_iso,
    pub __sockaddr_ns__: *const sockaddr_ns,
    pub __sockaddr_un__: *const sockaddr_un,
    pub __sockaddr_x25__: *const sockaddr_x25,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct stat {
    pub st_dev: __dev_t,
    pub st_ino: __ino_t,
    pub st_nlink: __nlink_t,
    pub st_mode: __mode_t,
    pub st_uid: __uid_t,
    pub st_gid: __gid_t,
    pub __pad0: i32,
    pub st_rdev: __dev_t,
    pub st_size: __off_t,
    pub st_blksize: __blksize_t,
    pub st_blocks: __blkcnt_t,
    pub st_atim: timespec,
    pub st_mtim: timespec,
    pub st_ctim: timespec,
    pub __glibc_reserved: [__syscall_slong_t; 3],
}
pub type va_list = __builtin_va_list;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct _IO_FILE {
    pub _flags: i32,
    pub _IO_read_ptr: *mut i8,
    pub _IO_read_end: *mut i8,
    pub _IO_read_base: *mut i8,
    pub _IO_write_base: *mut i8,
    pub _IO_write_ptr: *mut i8,
    pub _IO_write_end: *mut i8,
    pub _IO_buf_base: *mut i8,
    pub _IO_buf_end: *mut i8,
    pub _IO_save_base: *mut i8,
    pub _IO_backup_base: *mut i8,
    pub _IO_save_end: *mut i8,
    pub _markers: *mut _IO_marker,
    pub _chain: *mut _IO_FILE,
    pub _fileno: i32,
    pub _flags2: i32,
    pub _old_offset: __off_t,
    pub _cur_column: u16,
    pub _vtable_offset: i8,
    pub _shortbuf: [i8; 1],
    pub _lock: *mut (),
    pub _offset: __off64_t,
    pub _codecvt: *mut _IO_codecvt,
    pub _wide_data: *mut _IO_wide_data,
    pub _freeres_list: *mut _IO_FILE,
    pub _freeres_buf: *mut (),
    pub __pad5: size_t,
    pub _mode: i32,
    pub _unused2: [i8; 20],
}
pub type _IO_lock_t = ();
pub type FILE = _IO_FILE;
pub type cc_t = u8;
pub type speed_t = u32;
pub type tcflag_t = u32;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct termios {
    pub c_iflag: tcflag_t,
    pub c_oflag: tcflag_t,
    pub c_cflag: tcflag_t,
    pub c_lflag: tcflag_t,
    pub c_line: cc_t,
    pub c_cc: [cc_t; 32],
    pub c_ispeed: speed_t,
    pub c_ospeed: speed_t,
}
pub type uint64_t = __uint64_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event {
    pub ev_evcallback: event_callback,
    pub ev_timeout_pos: C2RustUnnamed_5,
    pub ev_fd: i32,
    pub ev_base: *mut event_base,
    pub ev_: C2RustUnnamed_0,
    pub ev_events: i16,
    pub ev_res: i16,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_0 {
    pub ev_io: C2RustUnnamed_3,
    pub ev_signal: C2RustUnnamed_1,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_1 {
    pub ev_signal_next: C2RustUnnamed_2,
    pub ev_ncalls: i16,
    pub ev_pncalls: *mut i16,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_2 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_3 {
    pub ev_io_next: C2RustUnnamed_4,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_4 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_5 {
    pub ev_next_with_common_timeout: C2RustUnnamed_6,
    pub min_heap_idx: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_6 {
    pub tqe_next: *mut event,
    pub tqe_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_callback {
    pub evcb_active_next: C2RustUnnamed_8,
    pub evcb_flags: i16,
    pub evcb_pri: uint8_t,
    pub evcb_closure: uint8_t,
    pub evcb_cb_union: C2RustUnnamed_7,
    pub evcb_arg: *mut (),
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_7 {
    pub evcb_callback: Option<unsafe extern "C" fn(i32, i16, *mut ()) -> ()>,
    pub evcb_selfcb: Option<unsafe extern "C" fn(*mut event_callback, *mut ()) -> ()>,
    pub evcb_evfinalize: Option<unsafe extern "C" fn(*mut event, *mut ()) -> ()>,
    pub evcb_cbfinalize: Option<unsafe extern "C" fn(*mut event_callback, *mut ()) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_8 {
    pub tqe_next: *mut event_callback,
    pub tqe_prev: *mut *mut event_callback,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct bufferevent {
    pub ev_base: *mut event_base,
    pub be_ops: *const bufferevent_ops,
    pub ev_read: event,
    pub ev_write: event,
    pub input: *mut evbuffer,
    pub output: *mut evbuffer,
    pub wm_read: event_watermark,
    pub wm_write: event_watermark,
    pub readcb: bufferevent_data_cb,
    pub writecb: bufferevent_data_cb,
    pub errorcb: bufferevent_event_cb,
    pub cbarg: *mut (),
    pub timeout_read: timeval,
    pub timeout_write: timeval,
    pub enabled: i16,
}
pub type bufferevent_event_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, i16, *mut ()) -> ()>;
pub type bufferevent_data_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, *mut ()) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_watermark {
    pub low: size_t,
    pub high: size_t,
}
pub type bitstr_t = u8;
pub type msgtype = u32;
pub const MSG_READ_CANCEL: msgtype = 307;
pub const MSG_WRITE_CLOSE: msgtype = 306;
pub const MSG_WRITE_READY: msgtype = 305;
pub const MSG_WRITE: msgtype = 304;
pub const MSG_WRITE_OPEN: msgtype = 303;
pub const MSG_READ_DONE: msgtype = 302;
pub const MSG_READ: msgtype = 301;
pub const MSG_READ_OPEN: msgtype = 300;
pub const MSG_FLAGS: msgtype = 218;
pub const MSG_EXEC: msgtype = 217;
pub const MSG_WAKEUP: msgtype = 216;
pub const MSG_UNLOCK: msgtype = 215;
pub const MSG_SUSPEND: msgtype = 214;
pub const MSG_OLDSTDOUT: msgtype = 213;
pub const MSG_OLDSTDIN: msgtype = 212;
pub const MSG_OLDSTDERR: msgtype = 211;
pub const MSG_SHUTDOWN: msgtype = 210;
pub const MSG_SHELL: msgtype = 209;
pub const MSG_RESIZE: msgtype = 208;
pub const MSG_READY: msgtype = 207;
pub const MSG_LOCK: msgtype = 206;
pub const MSG_EXITING: msgtype = 205;
pub const MSG_EXITED: msgtype = 204;
pub const MSG_EXIT: msgtype = 203;
pub const MSG_DETACHKILL: msgtype = 202;
pub const MSG_DETACH: msgtype = 201;
pub const MSG_COMMAND: msgtype = 200;
pub const MSG_IDENTIFY_TERMINFO: msgtype = 112;
pub const MSG_IDENTIFY_LONGFLAGS: msgtype = 111;
pub const MSG_IDENTIFY_STDOUT: msgtype = 110;
pub const MSG_IDENTIFY_FEATURES: msgtype = 109;
pub const MSG_IDENTIFY_CWD: msgtype = 108;
pub const MSG_IDENTIFY_CLIENTPID: msgtype = 107;
pub const MSG_IDENTIFY_DONE: msgtype = 106;
pub const MSG_IDENTIFY_ENVIRON: msgtype = 105;
pub const MSG_IDENTIFY_STDIN: msgtype = 104;
pub const MSG_IDENTIFY_OLDCWD: msgtype = 103;
pub const MSG_IDENTIFY_TTYNAME: msgtype = 102;
pub const MSG_IDENTIFY_TERM: msgtype = 101;
pub const MSG_IDENTIFY_FLAGS: msgtype = 100;
pub const MSG_VERSION: msgtype = 12;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client {
    pub name: *const i8,
    pub peer: *mut tmuxpeer,
    pub queue: *mut cmdq_list,
    pub windows: client_windows,
    pub control_state: *mut control_state,
    pub pause_age: u_int,
    pub pid: pid_t,
    pub fd: i32,
    pub out_fd: i32,
    pub event: event,
    pub retval: i32,
    pub creation_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub environ: *mut environ,
    pub jobs: *mut format_job_tree,
    pub title: *mut i8,
    pub path: *mut i8,
    pub cwd: *const i8,
    pub term_name: *mut i8,
    pub term_features: i32,
    pub term_type: *mut i8,
    pub term_caps: *mut *mut i8,
    pub term_ncaps: u_int,
    pub ttyname: *mut i8,
    pub tty: tty,
    pub written: size_t,
    pub discarded: size_t,
    pub redraw: size_t,
    pub repeat_timer: event,
    pub click_timer: event,
    pub click_button: u_int,
    pub click_event: mouse_event,
    pub status: status_line,
    pub flags: uint64_t,
    pub exit_type: C2RustUnnamed_31,
    pub exit_msgtype: msgtype,
    pub exit_session: *mut i8,
    pub exit_message: *mut i8,
    pub keytable: *mut key_table,
    pub last_key: key_code,
    pub redraw_panes: uint64_t,
    pub redraw_scrollbars: uint64_t,
    pub message_ignore_keys: i32,
    pub message_ignore_styles: i32,
    pub message_string: *mut i8,
    pub message_timer: event,
    pub prompt_string: *mut i8,
    pub prompt_buffer: *mut utf8_data,
    pub prompt_last: *mut i8,
    pub prompt_index: size_t,
    pub prompt_inputcb: prompt_input_cb,
    pub prompt_freecb: prompt_free_cb,
    pub prompt_data: *mut (),
    pub prompt_hindex: [u_int; 4],
    pub prompt_mode: C2RustUnnamed_28,
    pub prompt_saved: *mut utf8_data,
    pub prompt_flags: i32,
    pub prompt_type: prompt_type,
    pub prompt_cursor: i32,
    pub session: *mut session,
    pub last_session: *mut session,
    pub references: i32,
    pub pan_window: *mut (),
    pub pan_ox: u_int,
    pub pan_oy: u_int,
    pub overlay_check: overlay_check_cb,
    pub overlay_mode: overlay_mode_cb,
    pub overlay_draw: overlay_draw_cb,
    pub overlay_key: overlay_key_cb,
    pub overlay_free: overlay_free_cb,
    pub overlay_resize: overlay_resize_cb,
    pub overlay_data: *mut (),
    pub overlay_timer: event,
    pub files: client_files,
    pub clipboard_panes: *mut u_int,
    pub clipboard_npanes: u_int,
    pub entry: C2RustUnnamed_9,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_9 {
    pub tqe_next: *mut client,
    pub tqe_prev: *mut *mut client,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_files {
    pub rbh_root: *mut client_file,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_file {
    pub c: *mut client,
    pub peer: *mut tmuxpeer,
    pub tree: *mut client_files,
    pub references: i32,
    pub stream: i32,
    pub path: *mut i8,
    pub buffer: *mut evbuffer,
    pub event: *mut bufferevent,
    pub fd: i32,
    pub error: i32,
    pub closed: i32,
    pub cb: client_file_cb,
    pub data: *mut (),
    pub entry: C2RustUnnamed_10,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_10 {
    pub rbe_left: *mut client_file,
    pub rbe_right: *mut client_file,
    pub rbe_parent: *mut client_file,
    pub rbe_color: i32,
}
pub type client_file_cb = Option<
    unsafe extern "C" fn(*mut client, *const i8, i32, i32, *mut evbuffer, *mut ()) -> (),
>;
pub type overlay_resize_cb = Option<unsafe extern "C" fn(*mut client, *mut ()) -> ()>;
pub type overlay_free_cb = Option<unsafe extern "C" fn(*mut client, *mut ()) -> ()>;
pub type overlay_key_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *mut key_event) -> i32>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_event {
    pub key: key_code,
    pub m: mouse_event,
    pub buf: *mut i8,
    pub len: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct mouse_event {
    pub valid: i32,
    pub ignore: i32,
    pub key: key_code,
    pub statusat: i32,
    pub statuslines: u_int,
    pub x: u_int,
    pub y: u_int,
    pub b: u_int,
    pub lx: u_int,
    pub ly: u_int,
    pub lb: u_int,
    pub ox: u_int,
    pub oy: u_int,
    pub s: i32,
    pub w: i32,
    pub wp: i32,
    pub sgr_type: u_int,
    pub sgr_b: u_int,
}
pub type key_code = u64;
pub type overlay_draw_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *mut screen_redraw_ctx) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen_redraw_ctx {
    pub c: *mut client,
    pub statuslines: u_int,
    pub statustop: i32,
    pub pane_status: i32,
    pub pane_lines: pane_lines,
    pub pane_scrollbars: i32,
    pub pane_scrollbars_pos: i32,
    pub no_pane_gc: grid_cell,
    pub no_pane_gc_set: i32,
    pub sx: u_int,
    pub sy: u_int,
    pub ox: u_int,
    pub oy: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_cell {
    pub data: utf8_data,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: i32,
    pub bg: i32,
    pub us: i32,
    pub link: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct utf8_data {
    pub data: [u_char; 21],
    pub have: u_char,
    pub size: u_char,
    pub width: u_char,
}
pub type pane_lines = u32;
pub const PANE_LINES_NUMBER: pane_lines = 4;
pub const PANE_LINES_SIMPLE: pane_lines = 3;
pub const PANE_LINES_HEAVY: pane_lines = 2;
pub const PANE_LINES_DOUBLE: pane_lines = 1;
pub const PANE_LINES_SINGLE: pane_lines = 0;
pub type overlay_mode_cb = Option<
    unsafe extern "C" fn(*mut client, *mut (), *mut u_int, *mut u_int) -> *mut screen,
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen {
    pub title: *mut i8,
    pub path: *mut i8,
    pub titles: *mut screen_titles,
    pub grid: *mut grid,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub default_cstyle: screen_cursor_style,
    pub ccolour: i32,
    pub default_ccolour: i32,
    pub rupper: u_int,
    pub rlower: u_int,
    pub mode: i32,
    pub default_mode: i32,
    pub saved_cx: u_int,
    pub saved_cy: u_int,
    pub saved_grid: *mut grid,
    pub saved_cell: grid_cell,
    pub saved_flags: i32,
    pub tabs: *mut bitstr_t,
    pub sel: *mut screen_sel,
    pub write_list: *mut screen_write_cline,
    pub hyperlinks: *mut hyperlinks,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid {
    pub flags: i32,
    pub sx: u_int,
    pub sy: u_int,
    pub hscrolled: u_int,
    pub hsize: u_int,
    pub hlimit: u_int,
    pub linedata: *mut grid_line,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_line {
    pub celldata: *mut grid_cell_entry,
    pub cellused: u_int,
    pub cellsize: u_int,
    pub extddata: *mut grid_extd_entry,
    pub extdsize: u_int,
    pub flags: i32,
    pub time: time_t,
}
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_extd_entry {
    pub data: utf8_char,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: i32,
    pub bg: i32,
    pub us: i32,
    pub link: u_int,
}
pub type utf8_char = u_int;
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_cell_entry {
    pub c2rust_unnamed: C2RustUnnamed_11,
    pub flags: u_char,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_11 {
    pub offset: u_int,
    pub data: C2RustUnnamed_12,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_12 {
    pub attr: u_char,
    pub fg: u_char,
    pub bg: u_char,
    pub data: u_char,
}
pub type screen_cursor_style = u32;
pub const SCREEN_CURSOR_BAR: screen_cursor_style = 3;
pub const SCREEN_CURSOR_UNDERLINE: screen_cursor_style = 2;
pub const SCREEN_CURSOR_BLOCK: screen_cursor_style = 1;
pub const SCREEN_CURSOR_DEFAULT: screen_cursor_style = 0;
pub type overlay_check_cb = Option<
    unsafe extern "C" fn(
        *mut client,
        *mut (),
        u_int,
        u_int,
        u_int,
        *mut overlay_ranges,
    ) -> (),
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct overlay_ranges {
    pub px: [u_int; 3],
    pub nx: [u_int; 3],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct session {
    pub id: u_int,
    pub name: *mut i8,
    pub cwd: *const i8,
    pub creation_time: timeval,
    pub last_attached_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub lock_timer: event,
    pub curw: *mut winlink,
    pub lastw: winlink_stack,
    pub windows: winlinks,
    pub statusat: i32,
    pub statuslines: u_int,
    pub options: *mut options,
    pub flags: i32,
    pub attached: u_int,
    pub tio: *mut termios,
    pub environ: *mut environ,
    pub references: i32,
    pub gentry: C2RustUnnamed_14,
    pub entry: C2RustUnnamed_13,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_13 {
    pub rbe_left: *mut session,
    pub rbe_right: *mut session,
    pub rbe_parent: *mut session,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_14 {
    pub tqe_next: *mut session,
    pub tqe_prev: *mut *mut session,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlinks {
    pub rbh_root: *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink {
    pub idx: i32,
    pub session: *mut session,
    pub window: *mut window,
    pub flags: i32,
    pub entry: C2RustUnnamed_17,
    pub wentry: C2RustUnnamed_16,
    pub sentry: C2RustUnnamed_15,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_15 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_16 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_17 {
    pub rbe_left: *mut winlink,
    pub rbe_right: *mut winlink,
    pub rbe_parent: *mut winlink,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window {
    pub id: u_int,
    pub latest: *mut (),
    pub name: *mut i8,
    pub name_event: event,
    pub name_time: timeval,
    pub alerts_timer: event,
    pub offset_timer: event,
    pub activity_time: timeval,
    pub active: *mut window_pane,
    pub last_panes: window_panes,
    pub panes: window_panes,
    pub lastlayout: i32,
    pub layout_root: *mut layout_cell,
    pub saved_layout_root: *mut layout_cell,
    pub old_layout: *mut i8,
    pub sx: u_int,
    pub sy: u_int,
    pub manual_sx: u_int,
    pub manual_sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub new_sx: u_int,
    pub new_sy: u_int,
    pub new_xpixel: u_int,
    pub new_ypixel: u_int,
    pub fill_character: *mut utf8_data,
    pub flags: i32,
    pub alerts_queued: i32,
    pub alerts_entry: C2RustUnnamed_20,
    pub options: *mut options,
    pub references: u_int,
    pub winlinks: C2RustUnnamed_19,
    pub entry: C2RustUnnamed_18,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_18 {
    pub rbe_left: *mut window,
    pub rbe_right: *mut window,
    pub rbe_parent: *mut window,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_19 {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_20 {
    pub tqe_next: *mut window,
    pub tqe_prev: *mut *mut window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cell {
    pub type_0: layout_type,
    pub parent: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub wp: *mut window_pane,
    pub cells: layout_cells,
    pub entry: C2RustUnnamed_21,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_21 {
    pub tqe_next: *mut layout_cell,
    pub tqe_prev: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cells {
    pub tqh_first: *mut layout_cell,
    pub tqh_last: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane {
    pub id: u_int,
    pub active_point: u_int,
    pub window: *mut window,
    pub options: *mut options,
    pub layout_cell: *mut layout_cell,
    pub saved_layout_cell: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub flags: i32,
    pub sb_slider_y: u_int,
    pub sb_slider_h: u_int,
    pub argc: i32,
    pub argv: *mut *mut i8,
    pub shell: *mut i8,
    pub cwd: *mut i8,
    pub pid: pid_t,
    pub tty: [i8; 32],
    pub status: i32,
    pub dead_time: timeval,
    pub fd: i32,
    pub event: *mut bufferevent,
    pub offset: window_pane_offset,
    pub base_offset: size_t,
    pub resize_queue: window_pane_resizes,
    pub resize_timer: event,
    pub ictx: *mut input_ctx,
    pub cached_gc: grid_cell,
    pub cached_active_gc: grid_cell,
    pub palette: colour_palette,
    pub pipe_fd: i32,
    pub pipe_event: *mut bufferevent,
    pub pipe_offset: window_pane_offset,
    pub screen: *mut screen,
    pub base: screen,
    pub status_screen: screen,
    pub status_size: size_t,
    pub modes: C2RustUnnamed_25,
    pub searchstr: *mut i8,
    pub searchregex: i32,
    pub border_gc_set: i32,
    pub border_gc: grid_cell,
    pub control_bg: i32,
    pub control_fg: i32,
    pub scrollbar_style: style,
    pub entry: C2RustUnnamed_24,
    pub sentry: C2RustUnnamed_23,
    pub tree_entry: C2RustUnnamed_22,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_22 {
    pub rbe_left: *mut window_pane,
    pub rbe_right: *mut window_pane,
    pub rbe_parent: *mut window_pane,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_23 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_24 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style {
    pub gc: grid_cell,
    pub ignore: i32,
    pub fill: i32,
    pub align: style_align,
    pub list: style_list,
    pub range_type: style_range_type,
    pub range_argument: u_int,
    pub range_string: [i8; 16],
    pub width: i32,
    pub pad: i32,
    pub default_type: style_default_type,
}
pub type style_default_type = u32;
pub const STYLE_DEFAULT_POP: style_default_type = 2;
pub const STYLE_DEFAULT_PUSH: style_default_type = 1;
pub const STYLE_DEFAULT_BASE: style_default_type = 0;
pub type style_range_type = u32;
pub const STYLE_RANGE_USER: style_range_type = 6;
pub const STYLE_RANGE_SESSION: style_range_type = 5;
pub const STYLE_RANGE_WINDOW: style_range_type = 4;
pub const STYLE_RANGE_PANE: style_range_type = 3;
pub const STYLE_RANGE_RIGHT: style_range_type = 2;
pub const STYLE_RANGE_LEFT: style_range_type = 1;
pub const STYLE_RANGE_NONE: style_range_type = 0;
pub type style_list = u32;
pub const STYLE_LIST_RIGHT_MARKER: style_list = 4;
pub const STYLE_LIST_LEFT_MARKER: style_list = 3;
pub const STYLE_LIST_FOCUS: style_list = 2;
pub const STYLE_LIST_ON: style_list = 1;
pub const STYLE_LIST_OFF: style_list = 0;
pub type style_align = u32;
pub const STYLE_ALIGN_ABSOLUTE_CENTRE: style_align = 4;
pub const STYLE_ALIGN_RIGHT: style_align = 3;
pub const STYLE_ALIGN_CENTRE: style_align = 2;
pub const STYLE_ALIGN_LEFT: style_align = 1;
pub const STYLE_ALIGN_DEFAULT: style_align = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_25 {
    pub tqh_first: *mut window_mode_entry,
    pub tqh_last: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode_entry {
    pub wp: *mut window_pane,
    pub swp: *mut window_pane,
    pub mode: *const window_mode,
    pub data: *mut (),
    pub screen: *mut screen,
    pub prefix: u_int,
    pub entry: C2RustUnnamed_26,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_26 {
    pub tqe_next: *mut window_mode_entry,
    pub tqe_prev: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode {
    pub name: *const i8,
    pub default_format: *const i8,
    pub init: Option<
        unsafe extern "C" fn(*mut window_mode_entry, *mut cmd_find_state, *mut args) -> *mut screen,
    >,
    pub free: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub resize: Option<unsafe extern "C" fn(*mut window_mode_entry, u_int, u_int) -> ()>,
    pub update: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub key: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            key_code,
            *mut mouse_event,
        ) -> (),
    >,
    pub key_table: Option<unsafe extern "C" fn(*mut window_mode_entry) -> *const i8>,
    pub command: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            *mut args,
            *mut mouse_event,
        ) -> (),
    >,
    pub formats: Option<unsafe extern "C" fn(*mut window_mode_entry, *mut format_tree) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_find_state {
    pub flags: i32,
    pub current: *mut cmd_find_state,
    pub s: *mut session,
    pub wl: *mut winlink,
    pub w: *mut window,
    pub wp: *mut window_pane,
    pub idx: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_offset {
    pub used: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct colour_palette {
    pub fg: i32,
    pub bg: i32,
    pub palette: *mut i32,
    pub default_palette: *mut i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resizes {
    pub tqh_first: *mut window_pane_resize,
    pub tqh_last: *mut *mut window_pane_resize,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resize {
    pub sx: u_int,
    pub sy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub entry: C2RustUnnamed_27,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_27 {
    pub tqe_next: *mut window_pane_resize,
    pub tqe_prev: *mut *mut window_pane_resize,
}
pub type layout_type = u32;
pub const LAYOUT_WINDOWPANE: layout_type = 2;
pub const LAYOUT_TOPBOTTOM: layout_type = 1;
pub const LAYOUT_LEFTRIGHT: layout_type = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_panes {
    pub tqh_first: *mut window_pane,
    pub tqh_last: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink_stack {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
pub type prompt_type = u32;
pub const PROMPT_TYPE_INVALID: prompt_type = 255;
pub const PROMPT_TYPE_WINDOW_TARGET: prompt_type = 3;
pub const PROMPT_TYPE_TARGET: prompt_type = 2;
pub const PROMPT_TYPE_SEARCH: prompt_type = 1;
pub const PROMPT_TYPE_COMMAND: prompt_type = 0;
pub type C2RustUnnamed_28 = u32;
pub const PROMPT_COMMAND: C2RustUnnamed_28 = 1;
pub const PROMPT_ENTRY: C2RustUnnamed_28 = 0;
pub type prompt_free_cb = Option<unsafe extern "C" fn(*mut ()) -> ()>;
pub type prompt_input_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *const i8, i32) -> i32>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_table {
    pub name: *const i8,
    pub activity_time: timeval,
    pub key_bindings: key_bindings,
    pub default_key_bindings: key_bindings,
    pub references: u_int,
    pub entry: C2RustUnnamed_29,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_29 {
    pub rbe_left: *mut key_table,
    pub rbe_right: *mut key_table,
    pub rbe_parent: *mut key_table,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_bindings {
    pub rbh_root: *mut key_binding,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_binding {
    pub key: key_code,
    pub cmdlist: *mut cmd_list,
    pub note: *const i8,
    pub flags: i32,
    pub entry: C2RustUnnamed_30,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_30 {
    pub rbe_left: *mut key_binding,
    pub rbe_right: *mut key_binding,
    pub rbe_parent: *mut key_binding,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_list {
    pub references: i32,
    pub group: u_int,
    pub list: *mut cmds,
}
pub type C2RustUnnamed_31 = u32;
pub const CLIENT_EXIT_DETACH: C2RustUnnamed_31 = 2;
pub const CLIENT_EXIT_SHUTDOWN: C2RustUnnamed_31 = 1;
pub const CLIENT_EXIT_RETURN: C2RustUnnamed_31 = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line {
    pub timer: event,
    pub screen: screen,
    pub active: *mut screen,
    pub references: i32,
    pub style: grid_cell,
    pub entries: [status_line_entry; 5],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line_entry {
    pub expanded: *mut i8,
    pub ranges: style_ranges,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_ranges {
    pub tqh_first: *mut style_range,
    pub tqh_last: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_range {
    pub type_0: style_range_type,
    pub argument: u_int,
    pub string: [i8; 16],
    pub start: u_int,
    pub end: u_int,
    pub entry: C2RustUnnamed_32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_32 {
    pub tqe_next: *mut style_range,
    pub tqe_prev: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty {
    pub client: *mut client,
    pub start_timer: event,
    pub clipboard_timer: event,
    pub last_requests: time_t,
    pub sx: u_int,
    pub sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub ccolour: i32,
    pub oflag: i32,
    pub oox: u_int,
    pub ooy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub mode: i32,
    pub fg: i32,
    pub bg: i32,
    pub rlower: u_int,
    pub rupper: u_int,
    pub rleft: u_int,
    pub rright: u_int,
    pub event_in: event,
    pub in_0: *mut evbuffer,
    pub event_out: event,
    pub out: *mut evbuffer,
    pub timer: event,
    pub discarded: size_t,
    pub tio: termios,
    pub cell: grid_cell,
    pub last_cell: grid_cell,
    pub flags: i32,
    pub term: *mut tty_term,
    pub mouse_last_x: u_int,
    pub mouse_last_y: u_int,
    pub mouse_last_b: u_int,
    pub mouse_drag_flag: i32,
    pub mouse_scrolling_flag: i32,
    pub mouse_slider_mpos: i32,
    pub mouse_drag_update: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub mouse_drag_release: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub key_timer: event,
    pub key_tree: *mut tty_key,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty_term {
    pub name: *mut i8,
    pub tty: *mut tty,
    pub features: i32,
    pub acs: [[i8; 2]; 256],
    pub codes: *mut tty_code,
    pub flags: i32,
    pub entry: C2RustUnnamed_33,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_33 {
    pub le_next: *mut tty_term,
    pub le_prev: *mut *mut tty_term,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_windows {
    pub rbh_root: *mut client_window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_window {
    pub window: u_int,
    pub pane: *mut window_pane,
    pub sx: u_int,
    pub sy: u_int,
    pub entry: C2RustUnnamed_34,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_34 {
    pub rbe_left: *mut client_window,
    pub rbe_right: *mut client_window,
    pub rbe_parent: *mut client_window,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_tree {
    pub rbh_root: *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct windows {
    pub rbh_root: *mut window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sessions {
    pub rbh_root: *mut session,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct message_entry {
    pub msg: *mut i8,
    pub msg_num: u_int,
    pub msg_time: timeval,
    pub entry: C2RustUnnamed_35,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_35 {
    pub tqe_next: *mut message_entry,
    pub tqe_prev: *mut *mut message_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct message_list {
    pub tqh_first: *mut message_entry,
    pub tqh_last: *mut *mut message_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct clients {
    pub tqh_first: *mut client,
    pub tqh_last: *mut *mut client,
}
#[no_mangle]
pub static mut clients: clients = clients {
    tqh_first: 0 as *const client as *mut client,
    tqh_last: 0 as *const *mut client as *mut *mut client,
};
#[no_mangle]
pub static mut server_proc: *mut tmuxproc = 0 as *const tmuxproc as *mut tmuxproc;
static mut server_fd: i32 = -(1 as i32);
static mut server_client_flags: uint64_t = 0;
static mut server_exit: i32 = 0;
static mut server_ev_accept: event = event {
    ev_evcallback: event_callback {
        evcb_active_next: C2RustUnnamed_8 {
            tqe_next: 0 as *const event_callback as *mut event_callback,
            tqe_prev: 0 as *const *mut event_callback as *mut *mut event_callback,
        },
        evcb_flags: 0,
        evcb_pri: 0,
        evcb_closure: 0,
        evcb_cb_union: C2RustUnnamed_7 {
            evcb_callback: None,
        },
        evcb_arg: 0 as *const () as *mut (),
    },
    ev_timeout_pos: C2RustUnnamed_5 {
        ev_next_with_common_timeout: C2RustUnnamed_6 {
            tqe_next: 0 as *const event as *mut event,
            tqe_prev: 0 as *const *mut event as *mut *mut event,
        },
    },
    ev_fd: 0,
    ev_base: 0 as *const event_base as *mut event_base,
    ev_: C2RustUnnamed_0 {
        ev_io: C2RustUnnamed_3 {
            ev_io_next: C2RustUnnamed_4 {
                le_next: 0 as *const event as *mut event,
                le_prev: 0 as *const *mut event as *mut *mut event,
            },
            ev_timeout: timeval {
                tv_sec: 0,
                tv_usec: 0,
            },
        },
    },
    ev_events: 0,
    ev_res: 0,
    ev_timeout: timeval {
        tv_sec: 0,
        tv_usec: 0,
    },
};
static mut server_ev_tidy: event = event {
    ev_evcallback: event_callback {
        evcb_active_next: C2RustUnnamed_8 {
            tqe_next: 0 as *const event_callback as *mut event_callback,
            tqe_prev: 0 as *const *mut event_callback as *mut *mut event_callback,
        },
        evcb_flags: 0,
        evcb_pri: 0,
        evcb_closure: 0,
        evcb_cb_union: C2RustUnnamed_7 {
            evcb_callback: None,
        },
        evcb_arg: 0 as *const () as *mut (),
    },
    ev_timeout_pos: C2RustUnnamed_5 {
        ev_next_with_common_timeout: C2RustUnnamed_6 {
            tqe_next: 0 as *const event as *mut event,
            tqe_prev: 0 as *const *mut event as *mut *mut event,
        },
    },
    ev_fd: 0,
    ev_base: 0 as *const event_base as *mut event_base,
    ev_: C2RustUnnamed_0 {
        ev_io: C2RustUnnamed_3 {
            ev_io_next: C2RustUnnamed_4 {
                le_next: 0 as *const event as *mut event,
                le_prev: 0 as *const *mut event as *mut *mut event,
            },
            ev_timeout: timeval {
                tv_sec: 0,
                tv_usec: 0,
            },
        },
    },
    ev_events: 0,
    ev_res: 0,
    ev_timeout: timeval {
        tv_sec: 0,
        tv_usec: 0,
    },
};
#[no_mangle]
pub static mut marked_pane: cmd_find_state = cmd_find_state {
    flags: 0,
    current: 0 as *const cmd_find_state as *mut cmd_find_state,
    s: 0 as *const session as *mut session,
    wl: 0 as *const winlink as *mut winlink,
    w: 0 as *const window as *mut window,
    wp: 0 as *const window_pane as *mut window_pane,
    idx: 0,
};
static mut message_next: u_int = 0;
#[no_mangle]
pub static mut message_log: message_list = message_list {
    tqh_first: 0 as *const message_entry as *mut message_entry,
    tqh_last: 0 as *const *mut message_entry as *mut *mut message_entry,
};
#[no_mangle]
pub static mut current_time: time_t = 0;
#[no_mangle]
pub extern "C" fn server_set_marked(
    mut s: *mut session,
    mut wl: *mut winlink,
    mut wp: *mut window_pane,
) {
    (unsafe { cmd_find_clear_state(&mut marked_pane, 0) });
    (unsafe { marked_pane.s = s });
    (unsafe { marked_pane.wl = wl });
    (unsafe { marked_pane.w = (*wl).window });
    (unsafe { marked_pane.wp = wp });
}
#[no_mangle]
pub extern "C" fn server_clear_marked() {
    (unsafe { cmd_find_clear_state(&mut marked_pane, 0) });
}
#[no_mangle]
pub extern "C" fn server_is_marked(
    mut s: *mut session,
    mut wl: *mut winlink,
    mut wp: *mut window_pane,
) -> i32 {
    if s.is_null() || wl.is_null() || wp.is_null() {
        return 0;
    }
    if (unsafe { marked_pane.s }) != s || (unsafe { marked_pane.wl }) != wl {
        return 0;
    }
    if (unsafe { marked_pane.wp }) != wp {
        return 0;
    }
    return server_check_marked();
}
#[no_mangle]
pub extern "C" fn server_check_marked() -> i32 {
    return unsafe { cmd_find_valid_state(&mut marked_pane) };
}
#[no_mangle]
pub extern "C" fn server_create_socket(mut flags: uint64_t, mut cause: *mut *mut i8) -> i32 {
    let mut sa: sockaddr_un = sockaddr_un {
        sun_family: 0,
        sun_path: [0; 108],
    };
    let mut size: size_t = 0;
    let mut mask: mode_t = 0;
    let mut fd: i32 = 0;
    let mut saved_errno: i32 = 0;
    (unsafe {
        memset(
            &mut sa as *mut sockaddr_un as *mut (), 0,
            ::core::mem::size_of::<sockaddr_un>() as u64,
        )
    });
    sa.sun_family = 1 as sa_family_t;
    size = unsafe {
        strlcpy(
            (sa.sun_path).as_mut_ptr(),
            socket_path,
            ::core::mem::size_of::<[i8; 108]>() as u64,
        )
    };
    if size >= ::core::mem::size_of::<[i8; 108]>() as u64 {
        (unsafe { *__errno_location() = 36 });
    } else {
        (unsafe { unlink((sa.sun_path).as_mut_ptr()) });
        fd = unsafe { socket(1 as i32, SOCK_STREAM as i32, 0) };
        if fd != -(1 as i32) {
            if flags & 0x8000000 as i32 as u64 != 0 {
                mask = unsafe {
                    umask(
                        (0o100 as i32
                            | 0o100 as i32 >> 3
                            | (0o400 as i32 | 0o200 as i32 | 0o100 as i32) >> 3 >> 3)
                            as __mode_t,
                    )
                };
            } else {
                mask = unsafe {
                    umask(
                        (0o100 as i32
                            | (0o400 as i32 | 0o200 as i32 | 0o100 as i32) >> 3
                            | (0o400 as i32 | 0o200 as i32 | 0o100 as i32) >> 3 >> 3)
                            as __mode_t,
                    )
                };
            }
            if (unsafe {
                bind(
                    fd,
                    __CONST_SOCKADDR_ARG {
                        __sockaddr__: &mut sa as *mut sockaddr_un as *mut sockaddr,
                    },
                    ::core::mem::size_of::<sockaddr_un>() as u64 as socklen_t,
                )
            }) == -(1 as i32)
            {
                saved_errno = unsafe { *__errno_location() };
                (unsafe { close(fd) });
                (unsafe { *__errno_location() = saved_errno });
            } else {
                (unsafe { umask(mask) });
                if (unsafe { listen(fd, 128) }) == -(1 as i32) {
                    saved_errno = unsafe { *__errno_location() };
                    (unsafe { close(fd) });
                    (unsafe { *__errno_location() = saved_errno });
                } else {
                    (unsafe { setblocking(fd, 0) });
                    return fd;
                }
            }
        }
    }
    if !cause.is_null() {
        (unsafe {
            xasprintf(
                cause,
                b"error creating %s (%s)\0" as *const u8 as *const i8,
                socket_path,
                strerror(*__errno_location()),
            )
        });
    }
    return -(1 as i32);
}
extern "C" fn server_tidy_event(mut _fd: i32, mut _events: i16, mut _data: *mut ()) {
    let mut tv: timeval = {
        let mut init = timeval {
            tv_sec: 3600 as __time_t,
            tv_usec: 0,
        };
        init
    };
    let mut t: uint64_t = unsafe { get_timer() };
    (unsafe { format_tidy_jobs() });
    (unsafe { malloc_trim(0 as i32 as size_t) });
    (unsafe {
        log_debug(
            b"%s: took %llu milliseconds\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 18], &[i8; 18]>(b"server_tidy_event\0")).as_ptr(),
            (get_timer()).wrapping_sub(t) as u64,
        )
    });
    (unsafe { event_add(&mut server_ev_tidy, &mut tv) });
}
#[no_mangle]
pub extern "C" fn server_start(
    mut client: *mut tmuxproc,
    mut flags: uint64_t,
    mut base: *mut event_base,
    mut lockfd: i32,
    mut lockfile: *mut i8,
) -> i32 {
    let mut fd: i32 = 0;
    let mut set: sigset_t = sigset_t { __val: [0; 16] };
    let mut oldset: sigset_t = sigset_t { __val: [0; 16] };
    let mut c: *mut client = std::ptr::null_mut::<client>();
    let mut cause: *mut i8 = std::ptr::null_mut::<i8>();
    let mut tv: timeval = {
        let mut init = timeval {
            tv_sec: 3600 as __time_t,
            tv_usec: 0,
        };
        init
    };
    (unsafe { sigfillset(&mut set) });
    (unsafe { sigprocmask(0 as i32, &mut set, &mut oldset) });
    if !flags & KEYC_SENT as i32 as u64 != 0 {
        if (unsafe { proc_fork_and_daemon(&mut fd) }) != 0 {
            (unsafe { sigprocmask(2 as i32, &mut oldset, std::ptr::null_mut::<sigset_t>()) });
            return fd;
        }
    }
    (unsafe { proc_clear_signals(client, 0) });
    (unsafe { server_client_flags = flags });
    if (unsafe { event_reinit(base) }) != 0 {
        (unsafe { fatalx(b"event_reinit failed\0" as *const u8 as *const i8) });
    }
    (unsafe { server_proc = proc_start(b"server\0" as *const u8 as *const i8) });
    (unsafe {
        proc_set_signals(
            server_proc,
            Some(server_signal as unsafe extern "C" fn(i32) -> ()),
        )
    });
    (unsafe { sigprocmask(2 as i32, &mut oldset, std::ptr::null_mut::<sigset_t>()) });
    if (unsafe { log_get_level() }) > 1 {
        (unsafe { tty_create_log() });
    }
    if 0 != 0 {
        (unsafe { fatal(b"pledge failed\0" as *const u8 as *const i8) });
    }
    (unsafe { input_key_build() });
    (unsafe { windows.rbh_root = std::ptr::null_mut::<window>() });
    (unsafe { all_window_panes.rbh_root = std::ptr::null_mut::<window_pane>() });
    (unsafe { clients.tqh_first = std::ptr::null_mut::<client>() });
    (unsafe { clients.tqh_last = &mut clients.tqh_first });
    (unsafe { sessions.rbh_root = std::ptr::null_mut::<session>() });
    (unsafe { key_bindings_init() });
    (unsafe { message_log.tqh_first = std::ptr::null_mut::<message_entry>() });
    (unsafe { message_log.tqh_last = &mut message_log.tqh_first });
    (unsafe { gettimeofday(&mut start_time, std::ptr::null_mut::<()>()) });
    (unsafe { server_fd = server_create_socket(flags, &mut cause) });
    if (unsafe { server_fd }) != -(1 as i32) {
        server_update_socket();
    }
    if !flags & KEYC_SENT as i32 as u64 != 0 {
        c = unsafe { server_client_create(fd) };
    } else {
        (unsafe {
            options_set_number(
                global_options,
                b"exit-empty\0" as *const u8 as *const i8, 0 as i64,
            )
        });
    }
    if lockfd >= 0 {
        (unsafe { unlink(lockfile) });
        (unsafe { free(lockfile as *mut ()) });
        (unsafe { close(lockfd) });
    }
    if !cause.is_null() {
        if !c.is_null() {
            (unsafe { (*c).exit_message = cause });
            (unsafe { (*c).flags |= 0x4 as i32 as u64 });
        } else {
            (unsafe { fprintf(stderr, b"%s\n\0" as *const u8 as *const i8, cause) });
            (unsafe { exit(1 as i32) });
        }
    }
    (unsafe {
        event_set(
            &mut server_ev_tidy,
            -(1 as i32), 0 as i16,
            Some(server_tidy_event as unsafe extern "C" fn(i32, i16, *mut ()) -> ()),
            std::ptr::null_mut::<()>(),
        )
    });
    (unsafe { event_add(&mut server_ev_tidy, &mut tv) });
    (unsafe { server_acl_init() });
    server_add_accept(0 as i32);
    (unsafe {
        proc_loop(
            server_proc,
            Some(server_loop as unsafe extern "C" fn() -> i32),
        )
    });
    (unsafe { job_kill_all() });
    (unsafe { status_prompt_save_history() });
    (unsafe { exit(0 as i32) });
}
extern "C" fn server_loop() -> i32 {
    let mut c: *mut client = std::ptr::null_mut::<client>();
    let mut items: u_int = 0;
    (unsafe { current_time = time(std::ptr::null_mut::<time_t>()) });
    loop {
        items = unsafe { cmdq_next(std::ptr::null_mut::<client>()) };
        c = unsafe { clients.tqh_first };
        while !c.is_null() {
            if (unsafe { (*c).flags }) & 0x40000 as i32 as u64 != 0 {
                items = (items as u32).wrapping_add(unsafe { cmdq_next(c) }) as u_int as u_int;
            }
            c = unsafe { (*c).entry.tqe_next };
        }
        if items == 0 as u32 {
            break;
        }
    }
    (unsafe { server_client_loop() });
    if (unsafe { options_get_number(global_options, b"exit-empty\0" as *const u8 as *const i8) })
        == 0
        && (unsafe { server_exit }) == 0
    {
        return 0;
    }
    if (unsafe {
        options_get_number(
            global_options,
            b"exit-unattached\0" as *const u8 as *const i8,
        )
    }) == 0
    {
        if !(unsafe { sessions.rbh_root }).is_null() {
            return 0;
        }
    }
    c = unsafe { clients.tqh_first };
    while !c.is_null() {
        if !(unsafe { (*c).session }).is_null() {
            return 0;
        }
        c = unsafe { (*c).entry.tqe_next };
    }
    (unsafe { cmd_wait_for_flush() });
    if !(unsafe { clients.tqh_first }).is_null() {
        return 0;
    }
    if (unsafe { job_still_running() }) != 0 {
        return 0;
    }
    return 1;
}
extern "C" fn server_send_exit() {
    let mut c: *mut client = std::ptr::null_mut::<client>();
    let mut c1: *mut client = std::ptr::null_mut::<client>();
    let mut s: *mut session = std::ptr::null_mut::<session>();
    let mut s1: *mut session = std::ptr::null_mut::<session>();
    (unsafe { cmd_wait_for_flush() });
    c = unsafe { clients.tqh_first };
    while !c.is_null() && {
        c1 = unsafe { (*c).entry.tqe_next }; 1 != 0
    } {
        if (unsafe { (*c).flags }) & 0x40 as i32 as u64 != 0 {
            (unsafe { server_client_lost(c) });
        } else {
            (unsafe { (*c).flags |= 0x4 as i32 as u64 });
            (unsafe { (*c).exit_type = CLIENT_EXIT_SHUTDOWN });
        }
        (unsafe { (*c).session = std::ptr::null_mut::<session>() });
        c = c1;
    }
    s = unsafe { sessions_RB_MINMAX(&mut sessions, -(1 as i32)) };
    while !s.is_null() && {
        s1 = unsafe { sessions_RB_NEXT(s) }; 1 != 0
    } {
        (unsafe {
            session_destroy(
                s, 1,
                (*::core::mem::transmute::<&[u8; 17], &[i8; 17]>(b"server_send_exit\0")).as_ptr(),
            )
        });
        s = s1;
    }
}
#[no_mangle]
pub extern "C" fn server_update_socket() {
    let mut s: *mut session = std::ptr::null_mut::<session>();
    static mut last: i32 = -(1 as i32);
    let mut n: i32 = 0;
    let mut mode: i32 = 0;
    let mut sb: stat = stat {
        st_dev: 0,
        st_ino: 0,
        st_nlink: 0,
        st_mode: 0,
        st_uid: 0,
        st_gid: 0,
        __pad0: 0,
        st_rdev: 0,
        st_size: 0,
        st_blksize: 0,
        st_blocks: 0,
        st_atim: timespec {
            tv_sec: 0,
            tv_nsec: 0,
        },
        st_mtim: timespec {
            tv_sec: 0,
            tv_nsec: 0,
        },
        st_ctim: timespec {
            tv_sec: 0,
            tv_nsec: 0,
        },
        __glibc_reserved: [0; 3],
    };
    n = 0;
    s = unsafe { sessions_RB_MINMAX(&mut sessions, -(1 as i32)) };
    while !s.is_null() {
        if (unsafe { (*s).attached }) != 0 as u32 {
            n += 1;
            break;
        } else {
            s = unsafe { sessions_RB_NEXT(s) };
        }
    }
    if n != (unsafe { last }) {
        (unsafe { last = n });
        if (unsafe { stat(socket_path, &mut sb) }) != 0 {
            return;
        }
        mode = (sb.st_mode
            & (0o400 as i32
                | 0o200 as i32
                | 0o100 as i32
                | (0o400 as i32 | 0o200 as i32 | 0o100 as i32) >> 3
                | (0o400 as i32 | 0o200 as i32 | 0o100 as i32) >> 3 >> 3)
                as u32) as i32;
        if n != 0 {
            if mode & 0o400 as i32 != 0 {
                mode |= 0o100 as i32;
            }
            if mode & 0o400 as i32 >> 3 != 0 {
                mode |= 0o100 as i32 >> 3;
            }
            if mode & 0o400 as i32 >> 3 >> 3 != 0 {
                mode |= 0o100 as i32 >> 3 >> 3;
            }
        } else {
            mode &=
                !(0o100 as i32 | 0o100 as i32 >> 3 | 0o100 as i32 >> 3 >> 3);
        }
        (unsafe { chmod(socket_path, mode as __mode_t) });
    }
}
extern "C" fn server_accept(mut fd: i32, mut events: i16, mut _data: *mut ()) {
    let mut sa: sockaddr_storage = sockaddr_storage {
        ss_family: 0,
        __ss_padding: [0; 118],
        __ss_align: 0,
    };
    let mut slen: socklen_t = ::core::mem::size_of::<sockaddr_storage>() as u64 as socklen_t;
    let mut newfd: i32 = 0;
    let mut c: *mut client = std::ptr::null_mut::<client>();
    server_add_accept(0 as i32);
    if events as i32 & 0x2 as i32 == 0 {
        return;
    }
    newfd = unsafe {
        accept(
            fd,
            __SOCKADDR_ARG {
                __sockaddr__: &mut sa as *mut sockaddr_storage as *mut sockaddr,
            },
            &mut slen,
        )
    };
    if newfd == -(1 as i32) {
        if (unsafe { *__errno_location() }) == 11
            || (unsafe { *__errno_location() }) == 4
            || (unsafe { *__errno_location() }) == 103
        {
            return;
        }
        if (unsafe { *__errno_location() }) == 23
            || (unsafe { *__errno_location() }) == 24
        {
            server_add_accept(1 as i32);
            return;
        }
        (unsafe { fatal(b"accept failed\0" as *const u8 as *const i8) });
    }
    if (unsafe { server_exit }) != 0 {
        (unsafe { close(newfd) });
        return;
    }
    c = unsafe { server_client_create(newfd) };
    if (unsafe { server_acl_join(c) }) == 0 {
        (unsafe { (*c).exit_message = xstrdup(b"access not allowed\0" as *const u8 as *const i8) });
        (unsafe { (*c).flags |= 0x4 as i32 as u64 });
    }
}
#[no_mangle]
pub extern "C" fn server_add_accept(mut timeout: i32) {
    let mut tv: timeval = {
        let mut init = timeval {
            tv_sec: timeout as __time_t,
            tv_usec: 0 as __suseconds_t,
        };
        init
    };
    if (unsafe { server_fd }) == -(1 as i32) {
        return;
    }
    if (unsafe { event_initialized(&mut server_ev_accept) }) != 0 {
        (unsafe { event_del(&mut server_ev_accept) });
    }
    if timeout == 0 {
        (unsafe {
            event_set(
                &mut server_ev_accept,
                server_fd,
                0x2 as i32 as i16,
                Some(server_accept as unsafe extern "C" fn(i32, i16, *mut ()) -> ()),
                std::ptr::null_mut::<()>(),
            )
        });
        (unsafe { event_add(&mut server_ev_accept, std::ptr::null::<timeval>()) });
    } else {
        (unsafe {
            event_set(
                &mut server_ev_accept,
                server_fd,
                0x1 as i32 as i16,
                Some(server_accept as unsafe extern "C" fn(i32, i16, *mut ()) -> ()),
                std::ptr::null_mut::<()>(),
            )
        });
        (unsafe { event_add(&mut server_ev_accept, &mut tv) });
    };
}
extern "C" fn server_signal(mut sig: i32) {
    let mut fd: i32 = 0;
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 14], &[i8; 14]>(b"server_signal\0")).as_ptr(),
            strsignal(sig),
        )
    });
    match sig {
        2 | 15 => {
            (unsafe { server_exit = 1 });
            server_send_exit();
        }
        17 => {
            server_child_signal();
        }
        10 => {
            (unsafe { event_del(&mut server_ev_accept) });
            fd = server_create_socket(
                unsafe { server_client_flags },
                std::ptr::null_mut::<*mut i8>(),
            );
            if fd != -(1 as i32) {
                (unsafe { close(server_fd) });
                (unsafe { server_fd = fd });
                server_update_socket();
            }
            server_add_accept(0 as i32);
        }
        12 => {
            (unsafe { proc_toggle_log(server_proc) });
        }
        _ => {}
    };
}
extern "C" fn server_child_signal() {
    let mut status: i32 = 0;
    let mut pid: pid_t = 0;
    loop {
        pid = unsafe { waitpid(-(1 as i32), &mut status, 1 | 2) };
        match pid {
            -1 => {
                if (unsafe { *__errno_location() }) == 10 {
                    return;
                }
                (unsafe { fatal(b"waitpid failed\0" as *const u8 as *const i8) });
            }
            0 => return,
            _ => {}
        }
        if status & 0xff as i32 == 0x7f as i32 {
            server_child_stopped(pid, status);
        } else if status & 0x7f as i32 == 0
            || ((status & 0x7f as i32) + 1) as i8 as i32 >> 1 > 0
        {
            server_child_exited(pid, status);
        }
    }
}
extern "C" fn server_child_exited(mut pid: pid_t, mut status: i32) {
    let mut w: *mut window = std::ptr::null_mut::<window>();
    let mut w1: *mut window = std::ptr::null_mut::<window>();
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    w = unsafe { windows_RB_MINMAX(&mut windows, -(1 as i32)) };
    while !w.is_null() && {
        w1 = unsafe { windows_RB_NEXT(w) }; 1 != 0
    } {
        wp = unsafe { (*w).panes.tqh_first };
        while !wp.is_null() {
            if (unsafe { (*wp).pid }) == pid {
                (unsafe { (*wp).status = status });
                (unsafe { (*wp).flags |= 0x200 as i32 });
                (unsafe { log_debug(b"%%%u exited\0" as *const u8 as *const i8, (*wp).id) });
                (unsafe { (*wp).flags |= 0x100 as i32 });
                if (unsafe { window_pane_destroy_ready(wp) }) != 0 {
                    (unsafe { server_destroy_pane(wp, 1) });
                }
                break;
            } else {
                wp = unsafe { (*wp).entry.tqe_next };
            }
        }
        w = w1;
    }
    (unsafe { job_check_died(pid, status) });
}
extern "C" fn server_child_stopped(mut pid: pid_t, mut status: i32) {
    let mut w: *mut window = std::ptr::null_mut::<window>();
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    if (status & 0xff00 as i32) >> 8 == 21
        || (status & 0xff00 as i32) >> 8 == 22
    {
        return;
    }
    w = unsafe { windows_RB_MINMAX(&mut windows, -(1 as i32)) };
    while !w.is_null() {
        wp = unsafe { (*w).panes.tqh_first };
        while !wp.is_null() {
            if (unsafe { (*wp).pid }) == pid {
                if (unsafe { killpg(pid, 18) }) != 0 {
                    (unsafe { kill(pid, 18) });
                }
            }
            wp = unsafe { (*wp).entry.tqe_next };
        }
        w = unsafe { windows_RB_NEXT(w) };
    }
    (unsafe { job_check_died(pid, status) });
}
#[no_mangle]
pub unsafe extern "C" fn server_add_message(mut fmt: *const i8, mut args: ...) {
    let mut msg: *mut message_entry = std::ptr::null_mut::<message_entry>();
    let mut msg1: *mut message_entry = std::ptr::null_mut::<message_entry>();
    let mut s: *mut i8 = std::ptr::null_mut::<i8>();
    let mut ap: ::core::ffi::VaListImpl;
    let mut limit: u_int = 0;
    ap = args.clone();
    xvasprintf(&mut s, fmt, ap.as_va_list());
    log_debug(b"message: %s\0" as *const u8 as *const i8, s);
    msg = xcalloc( 1 as size_t,
        ::core::mem::size_of::<message_entry>() as u64,
    ) as *mut message_entry;
    gettimeofday(&mut (*msg).msg_time, std::ptr::null_mut::<()>());
    let fresh0 = message_next;
    message_next = message_next.wrapping_add(1);
    (*msg).msg_num = fresh0;
    (*msg).msg = s;
    (*msg).entry.tqe_next = std::ptr::null_mut::<message_entry>();
    (*msg).entry.tqe_prev = message_log.tqh_last;
    *message_log.tqh_last = msg;
    message_log.tqh_last = &mut (*msg).entry.tqe_next;
    limit =
        options_get_number(global_options, b"message-limit\0" as *const u8 as *const i8) as u_int;
    msg = message_log.tqh_first;
    while !msg.is_null() && {
        msg1 = (*msg).entry.tqe_next; 1 != 0
    } {
        if ((*msg).msg_num).wrapping_add(limit) >= message_next {
            break;
        }
        free((*msg).msg as *mut ());
        if !((*msg).entry.tqe_next).is_null() {
            (*(*msg).entry.tqe_next).entry.tqe_prev = (*msg).entry.tqe_prev;
        } else {
            message_log.tqh_last = (*msg).entry.tqe_prev;
        }
        *(*msg).entry.tqe_prev = (*msg).entry.tqe_next;
        free(msg as *mut ());
        msg = msg1;
    }
}
